home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1997 #3 / Amiga Plus CD - 1997 - No. 03.iso / pd / demo-versionen / maxoncpp4-demo / demo / supercode / lib&mem.c < prev    next >
C/C++ Source or Header  |  1996-12-31  |  8KB  |  340 lines
  1. //-------------------------------------
  2. //
  3. // SuperCode (c) 1996 by T.Kühn 
  4. //
  5. // Programmiersprache:    ANSI-C
  6. // Projektstart:            27.12.94
  7. //
  8. // Modul:                Libraries/Memory/Lists
  9. //
  10. //-------------------------------------
  11.  
  12. /*
  13.  
  14. VOID Lib_Init();
  15. VOID Lib_Free();
  16. VOID Lib_Open(struct Library **Base,UBYTE *Name,ULONG Version);
  17. VOID Lib_Close(struct Library **Base);
  18.  
  19. UBYTE *Memory_Alloc(long Size);
  20. UBYTE *MemGfx_Alloc(long Size);
  21. VOID Memory_Free(UBYTE **Mem);
  22.  
  23. VOID List_Init(struct tkList *List,void (*Func)() );
  24. VOID List_AddTail(struct tkList *List,APTR Node);
  25. VOID List_Remove(struct tkList *List,APTR Node);
  26. VOID List_Free(struct tkList *List);
  27. LONG List_FindNum(struct tkList *List,APTR Ptr,UBYTE *String);
  28. APTR List_FindPtr(struct tkList *Liste,LONG Num,UBYTE *String);
  29. LONG List_StrCmp(struct tkNode *Node1,struct tkNode *Node2);
  30. LONG List_FuncCmp(struct FuncItem *Func1,struct FuncItem *Func2);
  31. VOID List_QuickSort(struct tkNode **Array,register LONG Left,register LONG Right,LONG (*Func)(const void*,const void*));
  32. VOID List_Sort(struct tkList *List,long (*Func)(const void*,const void*));
  33. */
  34.  
  35. //-------------------------------------
  36.  
  37. #include <clib/alib_protos.h>
  38. #include <pragma/exec_lib.h>
  39. #include <exec/memory.h>
  40. #include <exec/libraries.h>
  41. #include <string.h>
  42.  
  43. #include <Struct.h>
  44.  
  45. //-------------------------------------
  46. struct Library
  47.     *GadToolsBase=0,
  48.     *IntuitionBase=0,
  49.     *LayersBase=0,
  50.     *GfxBase=0,
  51.     *WorkbenchBase=0,
  52.     *CxBase=0,
  53.     *KeymapBase=0,
  54.     *LocaleBase=0,
  55.     *UtilityBase=0,
  56.     *IFFParseBase=0,
  57.     *AslBase=0;
  58.  
  59.  
  60. //-------------------------------------
  61. VOID Lib_Open(struct Library **Base,UBYTE *Name,ULONG Version)
  62. {
  63.     ULONG ThisVersion=Version;
  64.     ULONG err;
  65.  
  66.     do    {    err=ASK_CONT;
  67.             (*Base)=OpenLibrary(Name,0);
  68.             ThisVersion=(*Base)->lib_Version;
  69.  
  70.             if (!(*Base)) err=display_error(ERR_LIB,ASK_EXIT|ASK_AGAIN|ASK_CONT,Name,Version);
  71.             else if (ThisVersion<Version) err=display_error(ERR_LIB2,ASK_EXIT|ASK_AGAIN|ASK_CONT,Name,Version,ThisVersion)
  72.  
  73.         } while(err==ASK_AGAIN)
  74. }
  75. //-------------------------------------
  76. VOID Lib_Close(struct Library **Base)
  77. {
  78.     if (*Base) { CloseLibrary(*Base);*Base=0; }
  79. }
  80. //-------------------------------------
  81. UBYTE *Memory_Alloc(long Size)
  82. {
  83.     APTR Ptr=0;
  84.     if (Size)
  85.     {
  86.         do    { Ptr=AllocVec(Size,MEMF_CLEAR);
  87.             } while((!Ptr) && ASK_AGAIN==display_error(ERR_MEM,ASK_EXIT|ASK_AGAIN,Size))
  88.     }
  89.     return(Ptr);
  90. }
  91. //-------------------------------------
  92. UBYTE *MemGfx_Alloc(long Size)
  93. {
  94.     APTR Ptr=0;
  95.  
  96.     if (Size)
  97.     {
  98.         do    { Ptr=AllocVec(Size,MEMF_CLEAR|MEMF_CHIP);
  99.             } while((!Ptr) && ASK_AGAIN==display_error(ERR_MEMC,ASK_EXIT|ASK_AGAIN,Size))
  100.     }
  101.  
  102.     return(Ptr);
  103. }
  104. //-------------------------------------
  105. VOID Memory_Free(UBYTE **Mem)
  106. {
  107.     if (Mem && (*Mem) )
  108.     {
  109.         FreeVec( (*Mem) );
  110.         (*Mem)=0;
  111.     }
  112. }
  113. //-------------------------------------
  114. VOID Lib_Init()
  115. {
  116.     Lib_Open(&IntuitionBase,"intuition.library",LibVersion);
  117.     Lib_Open(&GfxBase,"graphics.library",LibVersion);
  118.     Lib_Open(&LayersBase,"layers.library",LibVersion);
  119.     Lib_Open(&GadToolsBase,"gadtools.library",LibVersion);
  120.     Lib_Open(&WorkbenchBase,"workbench.library",LibVersion);
  121.     Lib_Open(&CxBase,"commodities.library",LibVersion);
  122.     Lib_Open(&KeymapBase,"keymap.library",LibVersion);
  123.     Lib_Open(&LocaleBase,"locale.library",LibVersion);
  124.     Lib_Open(&UtilityBase,"utility.library",LibVersion);
  125.     Lib_Open(&IFFParseBase,"iffparse.library",LibVersion);
  126.     Lib_Open(&AslBase,"asl.library",LibVersion);
  127. }
  128. //-------------------------------------
  129. VOID Lib_Free()
  130. {
  131.     Lib_Close(&AslBase);
  132.     Lib_Close(&IFFParseBase);
  133.     Lib_Close(&UtilityBase);
  134.     Lib_Close(&LocaleBase);
  135.     Lib_Close(&KeymapBase);
  136.     Lib_Close(&CxBase);
  137.     Lib_Close(&WorkbenchBase);
  138.     Lib_Close(&GadToolsBase);
  139.     Lib_Close(&LayersBase);
  140.     Lib_Close(&GfxBase);
  141.     Lib_Close(&IntuitionBase);
  142. }
  143. //-------------------------------------
  144.  
  145.  
  146. //-------------------------------------
  147. VOID List_Init(struct tkList *List,ULONG type,void (*Func)() )
  148. {
  149.     NewList( (struct List *)List );
  150.     List->lh_Type=type;
  151.     List->lh_Numb=0;
  152.     List->lh_Free=Func;
  153. }
  154. //-------------------------------------
  155. VOID List_AddTail(struct tkList *List,struct tkNode *Node)
  156. {
  157.     AddTail((struct List*)List,(struct Node*)Node);
  158.     List->lh_Numb++;
  159.     List->Sort=FALSE;
  160. }
  161. //-------------------------------------
  162. VOID List_AddSort(struct tkList *List,struct tkNode *Node,long (*Func)(const void*,const void*))
  163. {
  164.     struct tkNode *Node2=List->lh_Head;
  165.     struct tkNode *node_insert=0;
  166.  
  167.     if (Func && Node2)
  168.     {
  169.         while(Node2->ln_Succ)
  170.         {
  171.             if (1==(*Func)(Node2,Node))
  172.             {
  173.                 node_insert=Node2->ln_Pred;
  174.                 break;
  175.             }
  176.             (*Func)(Node2,Node);
  177.             node_insert=Node2;
  178.             Node2=Node2->ln_Succ;
  179.         }
  180.         Insert((struct List*)List,(struct Node*)Node,(struct Node*)node_insert);
  181.     }
  182. }
  183. //-------------------------------------
  184. VOID List_Remove(struct tkList *List,APTR Node)
  185. {
  186.     Remove(Node);
  187.     List->lh_Numb--;
  188. }
  189. //-------------------------------------
  190. VOID List_Free(struct tkList *List)
  191. {
  192.     struct tkNode *Node;
  193.  
  194.     while (!Empty(List))
  195.     {
  196.         Node=(APTR)List->lh_Head;
  197.         if (List->lh_Free) (*List->lh_Free)(Node);
  198.         List_Remove(List,Node);
  199.         Memory_Free( (APTR)&Node);
  200.     }
  201. }
  202. //-------------------------------------
  203. LONG List_FindNum(struct tkList *List,APTR Ptr,UBYTE *String)
  204. {
  205.     struct tkNode *List1=List->lh_Head;
  206.     register UBYTE *Str1,*Str2;
  207.     WORD count,Num;
  208.     BOOL Found=FALSE;
  209.  
  210.     if (Ptr)
  211.     {
  212.         for(Num=0 ; ((List1->ln_Succ!=0)&&(Found==FALSE)) ; Num++,List1=List1->ln_Succ )
  213.         {
  214.             if (Ptr==List1) Found=TRUE;
  215.         };
  216.     }
  217.     else
  218.     {
  219.         for(Num=0 ; ((List1->ln_Succ!=0)&&(Found==FALSE)) ; Num++,List1=List1->ln_Succ )
  220.         {
  221.             Str1=(List1->ln_Name);
  222.             Str2=String;
  223.             for (    count=0;
  224.                     (*Str1!=0) && (count<31) && ((UBYTE)(*Str1&0xDF)==(UBYTE)(*Str2&0xDF));
  225.                     count++,Str1++,Str2++);
  226.             if ( ((UBYTE)(*Str1&0xDF)>(UBYTE)(*Str2&0xDF)) || (*Str2==0)) Found=TRUE;
  227.         };
  228.     }
  229.     if (!Found) Num=0;
  230.     return(Num-1)
  231. }
  232. //-------------------------------------
  233. APTR List_FindPtr(struct tkList *Liste,LONG Num,UBYTE *String)
  234. {
  235.     register struct tkNode *Node=Liste->lh_Head;
  236.     register struct tkNode *NodeBack=0;
  237.     register UBYTE Asc;
  238.  
  239.     if (!String)
  240.     {
  241.         for (;(Node->ln_Succ!=0)&&(Num>0);Num--,Node=Node->ln_Succ);
  242.         NodeBack=Node;
  243.     }
  244.     else
  245.     {
  246.         if (String[0]!='?')
  247.         {
  248.             Asc=String[0]&0xDF;
  249.             for(; Node->ln_Succ ; Node=Node->ln_Succ )
  250.                 if (Asc>=(Node->ln_Name[0]&0xDF) ) break;
  251.         }
  252.  
  253. //        if (Num==FIND_NEARLY)
  254. //        {
  255. //                for(; Node->ln_Succ ; Node=Node->ln_Succ )
  256. //                if (0<=stricmp(Node->ln_Name,String)) {NodeBack=Node;break;}
  257. //        }
  258. //        else
  259.         {
  260.             for(; Node->ln_Succ ; Node=Node->ln_Succ )
  261.                 if (0==stricmp(Node->ln_Name,String)) {NodeBack=Node;break;};
  262.         }
  263.     }
  264.     return(NodeBack);
  265. }
  266. //-------------------------------------
  267. LONG List_StrCmp(struct tkNode *Node1,struct tkNode *Node2)
  268. {
  269.     return(stricmp(Node1->ln_Name,Node2->ln_Name));    
  270. }
  271. //-------------------------------------
  272. VOID List_QuickSort(struct tkNode **Array,register LONG Left,register LONG Right,LONG (*Func)(const void*,const void*))
  273. {
  274.     register LONG i=Left,j=Right;
  275.     register struct tkNode *Swap,*Test=Array[(i+j)/2];
  276.  
  277.     do
  278.     {
  279.         while (-1==(*Func)(Array[i],Test)) i++;
  280.         while ( 1==(*Func)(Array[j],Test)) j--;
  281.         if (i<=j)
  282.         {
  283.             Swap=Array[i];
  284.             Array[i]=Array[j];
  285.             Array[j]=Swap;
  286.             i++;j--;
  287.         }
  288.     } while (i <= j);
  289.  
  290.     if (Left<j)  List_QuickSort(Array,Left,j,Func);
  291.     if (Right>i) List_QuickSort(Array,i,Right,Func);
  292. }
  293. //-------------------------------------
  294. VOID List_Sort(struct tkList *List,long (*Func)(const void*,const void*))
  295. {
  296.     struct tkNode *Node,**Array;
  297.     LONG Count,i;
  298.  
  299.     if (!List->Sort)
  300.     {
  301.         Node=List->lh_Head;
  302.         for (Count=-1;(Node);Count++,Node=Node->ln_Succ);
  303.     
  304.         if (Count>1)
  305.         {
  306.             Array=(struct tkNode**)Memory_Alloc( (Count+2)*4 );
  307.             for (i=0,Node=List->lh_Head;(Node->ln_Succ);Node=Node->ln_Succ)
  308.             {
  309.                 Array[i++]=Node;
  310.                 Remove((APTR)Node);
  311.             }
  312.             if (!Func) Func=(APTR)List_StrCmp;
  313.  
  314.             List_QuickSort(Array,0,Count-1,Func);
  315.  
  316.             for (i=0;i<Count;i++) AddTail((APTR)List,(APTR)Array[i]);
  317.             Memory_Free( (APTR)&Array);
  318.         }
  319.         List->Sort=TRUE;
  320.     }
  321. }
  322. //-------------------------------------
  323. VOID List_DoAll(struct tkList *List,long (*Func)(const void*,APTR data),APTR data)
  324. {
  325.     struct tkNode *Node;
  326.  
  327.     Node=List->lh_Head;
  328.     
  329.     if (Func)
  330.     {
  331.         while(Node->ln_Succ)
  332.         {
  333.             (*Func)(Node,data);
  334.             Node=Node->ln_Succ;
  335.         }
  336.     }
  337. }
  338. //-------------------------------------
  339.  
  340.